COMMENT ⊗   VALID 00007 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002			DIFFERENCES BETWEEN "E" AND "TV"
C00006 00003			MINOR INCOMPATIBILITIES
C00010 00004			ADDITIONAL FEATURES IN ATTACH MODE
C00015 00005			ADDITIONAL SEARCH FEATURES
C00020 00006			ADDITIONAL SEARCH FEATURES (cont)
C00022 00007			MISCELLANEOUS FEATURES
C00026 ENDMK
C⊗;
		DIFFERENCES BETWEEN "E" AND "TV"

	This document is intended to help TV users get started using E.
The reader is assumed to be fairly familiar with TV so only the differences
are explained here. The most important differences, of course are that E
is somewhat smaller (only somewhat because RAID is currently kept in it),
considerably more efficient, and will eventually have many more features.
For these reasons, use of E rather than TV is encouraged, and eventually
TV will be phased out. Usage will also aid in finding bugs, although even
now the reliability of E seems to be greater than that of TV.

	At the present time, E still lacks a few of the less crucial features
of TV, but all commonly used features are implemented. The following things are
unavailable:

	File format conversion. If your file is not in E/TV format, you must use
	TV to do the conversion. Running E with an unconverted file will type
	an error message and exit. A related missing feature is the /N switch.

	The ⊗XSWITCH command to begin editing a different file. This will
	eventually be implemented in a better way as one of a whole set of
	changes to be made to the I/O structure. In the meantime, you lose.

	The αD and β<space> attach mode commands.

	The ⊗F<string>⊗F sequence.

	The ⊗F<string>⊗P sequence, which presently (in E) does a fairly
	strange thing that probably isn't what you wanted.

	The HISTORY feature. This is the subject of some controversy, since
	some people have specifically requested its omission, but in any case,
	since it is both a highly specialized feature and one which can be
	done manually without a great deal of difficulty, its priority for
	implementation is fairly low. So at least for the time being, the
	SAIL hackers will have to document their changes without having their
	arms twisted to do it (if they want to use E).
		MINOR INCOMPATIBILITIES

	E has one more position of the arrow than TV does: pointing at the
bottom row of stars. This allows "at the very end" to be a legitimate cursor
location and avoids the kludgery TV has to get around its limitation (sometimes)
for positioning ATTACHed text, as well as the ways TV sometimes has of dying
horribly when trying to do certain things on a totally blank page. E will still
do the right thing when typing lines of text in this position, although line
insert mode is usually a slightly better way of doing this (and is not less
efficient, as it is in TV).

	When first getting into intraline edit mode, E does not clear the input
buffer as TV does but instead attempts to preserve typeahead as much as possible.
This means that typing several characters before the line editor cursor appears
will usually work, but will still occasionally screw up due to problems in the
system. A good method is to go on typing, but to look at the line editor when
it appears and see if it looks right. If it doesn't (usually has some characters
shuffled around), hit ALT and try again. DON'T ACTIVATE IT with anything but ALT
if it's wrong, since the results are highly unpredictable. If you want to be
absolutely safe, observe the restrictions of TV. As in TV, none of this applies
to editing previously blank lines.

	When typing text in line insert mode, or in intraline edit mode on a
previously blank line, insufficient information is provided by the system to
correctly execute commands (activation chars) typed in the middle of the line
(such as β<cr>, for example). When entering text in these modes, don't type
activators other thar CR or ALT except at the end of the line. Also avoid
αD at the end.

	In search commands (⊗F and ⊗XF ), E does different types of searches
depending on whether control or control-meta is used. Use control alone on
these commands to get the same effect as TV, and also quote (with ≡) all
occurrences in the search string of any SOS special search characters (¬|∀≡∞)
and the character ⊂.

	The effect of ⊗F<string>⊗S is gotten in E by saying αF<string>α<cr>.
For more information, see the section of this blurb on searches.

	Different functions are assigned to the <ff> commands. See Miscellaneous
Features.

	Of course, the RPG commands for running E are different. "TV" becomes
"ETV" or "ET", and "CTV" becomes "CETV" or just "CE".
		ADDITIONAL FEATURES IN ATTACH MODE

	Both ⊗A and ⊗C may take negative arguments, in which case they
refer to <arg> lines BEFORE the the current line (non-inclusive; the
pointer is logically between two lines). However, beware of using
negative arguments when already attached - minus (as well as plus)
flags the arg as RELATIVE, which for attach commands means relative to
the number already attached. As usual, the default arg is 1 with the
specified sign.

	The default arg for ⊗C when already attached is the current number
of attached lines, rather than 1. As in TV, a ⊗E is simulated before doing
the ⊗C, so the effect is to place a copy of the attached text in the page
at the current position and retain a copy of that text in the attach buffer.

	Relative arguments to ⊗A and ⊗C allow lines to be added to or
removed from the end of the attach  buffer. ⊗A merely adds the current
attach size to the arg and simulates a ⊗E before the ⊗A, so ⊗+⊗<arg>⊗A
will transfer <arg> more lines into tha attach buffer from the page.
⊗-⊗<arg>⊗A transfers <arg> lines the other way. The appearance on the
screen (until the 8-line limit is reached) is that the text is unchanged
but the number of |'s increases or decreases appropriately.

	Relative arguments to ⊗C are handled specially to get a more useful
effect than the ⊗E simulation provides. ⊗+⊗<arg>⊗C copies <arg> lines past
the current location into the end of the attach buffer and moves down past
them, so that additional ⊗+⊗C commands will copy succesive lines. ⊗-⊗<arg>⊗C
throws away <arg> lines from the end of the attach buffer, so you may get
rid of some if you attached too many. Also, if the current location is the
same as the location of the last ⊗C or ⊗+⊗C, it will move up <arg> lines,
thus passing the original copies of the lines that were deleted, such that
a copy of some text can be created in a given place and adjusted larger
and smaller as much as desired without having to use explicit moving
commands. Note that the relative ⊗C commands never have any effect on the
page itself, but their effect is solely upon the attach buffer.

	To summarize relative attach commands, their effect for both ⊗A
and ⊗C is to enlarge or reduce the size of the attach buffer by the specified
amount, the difference being in the effect on the page. Relative ⊗A always
transfers the lines one way or the other so that nothing is gained or lost
and the text on the SCREEN remains unchanged, while relative ⊗C always copies
or throws away the lines such that the text on the PAGE remains unchanged.

	There are two other minor changes to attach mode, both in ⊗R. One
is that attached text is not saved after ⊗K as in TV, since this takes up
core, gets much more complicated with the relative commands, and doesn't
protect you from screwing yourself in any way you can't also do with ⊗D.
Perhaps someday when attached text is saved in a file for crash immunity...,
but for now ⊗R after ⊗K is a no-op. The other change is that ⊗R will act
like ⊗K rather than replacing the text in any case where the text was not
really removed from its source.
		ADDITIONAL SEARCH FEATURES

	E eventually intends to implement all of the SOS search features, as
well as a couple more, and its search string processor currently recognizes
all the intended special characters. The complete list of these characters
is ¬|∀≡∞⊂, of which only ⊂ is a character not used similarly by SOS. The characters
¬|∀≡ are implemented with the same functions as they have in SOS, with the exception
that ∀ matches truly everything and ¬∀ truly nothing. The characters ∞⊂ are for
presently unimplemented features and produce the message SEARCH STRING TOO COMPLEX.
All of these characters may be quoted with ≡ as in SOS.

	Some complications are added by <cr>s. SOS uses <cr> as a special character
in a search string, whereas in TV the <cr> will terminate the search string. E
provides both options by having two possible formats of search command. One is
<search command><string><activation char>, where <string> contains no activators,
including <cr>s. This format is identical to TV search command format. The second
format is <search command><lf><string><lf><switches><activation char>, where
<string> may contain <cr>s but no other activators and <switches> is presently
ignored but will eventually allow options to be specified. This format is fairly
similar to SOS search specifications, with <lf> taking the place of <alt> and
an extra one immediately after the command to indicate format 2. Unlike SOS,
<cr>s can be quoted with ≡ and will match line boundaries (¬∀ will NOT do this).
This is in fact the only present use of the second format, since the multiple
string search is not yet implemented. Incidentally, search strings may in general
cross line boundaries whenever they contain any characters which will match
<cr> (such as | and ∀).

	Getting into more detail on the search command itself, there are four
commands which can be used for <search command> above. The two basic forms are
πF for current-page-only searching and πXF<space> for multipage searches. The
"π" in each case should be <control> for a regular search or <control-meta>
for a delimited search (as if you had really said |<string>| instead of
<string>. This latter mode is handy for finding identifiers, etc. Note that
the implicit |s do NOT count in determining the origin of the string for things
like line editor positioning, etc.

	As in TV, the activation character terminating the search command is
taken as a command to be executed after the string is found. If the command
is not actually specified at that point, due to the activator really being
an argument digit, etc., the rest of the command must be typed before the search
will actually begin. For most non-line-editor commands, the command will merely
be executed with the arrow at the beginning of the line containing the string,
but ⊗A, ⊗C, and ⊗D operate on the range between the old and new arrow positions
as in TV. However, if they are used with the extended search and the string is
not found on the current page, the range will not cross the page boundary but
will instead begin at the top of the final page.
		ADDITIONAL SEARCH FEATURES (cont)

	E also keeps track of the position of the string within the line, as well
as the line. If the search command is terminated with a line editor command,
this is used to position the line editor cursor to the beginning of the string
in the line before executing the command. If another search string is typed, this
is used to start the next search on the next CHARACTER, rather than the next line,
so multiple occurrences of the string within the line will be found. This offset
is set to zero any time the arrow is moved or the line changed. To position the
line editor to the string without performing any subsequent command, terminate
the search command with α<cr>. Also, typing α<cr> alone any time this offset is
in effect will do the positioning, so if you use <cr> instead of α<cr> with the
search, you can still get to the string easily.

	Finally, unlike TV, search commands take any numeric argument as a repeat
count and find the n'th occurrence of the string. Negative arguments are not yet
implemented.
		MISCELLANEOUS FEATURES

	E provides a mechanism for having multiple contiguous pages treated as
the "current page". These pages are separated on the screen by funny lines
which act like the bottom row of stars if you try to type onto them and delete
their corresponding page marks if you delete them with ⊗D. These lines can be
created with β<ff> (yup, it's inserting a form-feed) for breaking up an existing
page. In addition the ⊗XAPPEND command reads in an additional page after the
current one and appends it to the current page with a page mark line separating
it. Then these pages can all be edited at once and will all be written at once.
A ⊗XCANCEL resets to having only the first current page read in. Naturally,
excessive use of this feature is ill-advised, since it increases core size and
hence time to get swapped in.

	E uses a compatible, but slightly different, directory page format. This
consists mainly of arranging for each line to start with the letter "C" to make
FORTRAN happy. If a file with the extension .F4 is edited with E and the directory
is in TV format, E will ask if a new directory should be written immediately.
Otherwise, the conversion will take place the first time the directory is written
for any normal reason, although it will always be displayed as if it were in E
format.

	E maintains some status indicators at the end of the page header line.
These consist of (optionally) the letters "W", "X", and "D". "W" means the page
has been altered since it was read in and hence needs to be written. "X" means
the page has exceeded its presently allotted number of records in the file and
will cause "bubbling" when it it written unless it is the last page of the file.
"D" means a change has been made which affects the directory and will cause the
directory to be written along with the current page. This may occasionally cause
"bubbling", which is not necessarily anticipated by an "X".

	The command <ff> in E does a ⊗W if the bottom of the page is not visible
or a ⊗P if it is. This is useful for looking through a file without having to
switch back and forth between two commands.

	The command ⊗XLINCNT types the number of lines in the current page, which
is useful for fitting things onto line printer (or XGP) pages.